﻿/*

Tooltipster 3.1.2 | 2014-03-17
A rockin' custom tooltip jQuery plugin

Developed by Caleb Jacob under the MIT license http://opensource.org/licenses/MIT

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

; (function ($, window, document) {

    var pluginName = "tooltipster",
		defaults = {
		    animation: 'fade',
		    arrow: true,
		    arrowColor: '',
		    autoClose: true,
		    content: null,
		    contentAsHTML: false,
		    contentCloning: true,
		    delay: 200,
		    fixedWidth: 0,
		    maxWidth: 0,
		    functionInit: function (origin, content) { },
		    functionBefore: function (origin, continueTooltip) {
		        continueTooltip();
		    },
		    functionReady: function (origin, tooltip) { },
		    functionAfter: function (origin) { },
		    icon: '(?)',
		    iconCloning: true,
		    iconDesktop: false,
		    iconTouch: false,
		    iconTheme: 'tooltipster-icon',
		    interactive: false,
		    interactiveTolerance: 350,
		    offsetX: 0,
		    offsetY: 0,
		    onlyOne: false,
		    position: 'top',
		    positionTracker: false,
		    speed: 350,
		    timer: 0,
		    theme: 'tooltipster-default',
		    touchDevices: true,
		    trigger: 'hover',
		    updateAnimation: true
		};

    function Plugin(element, options) {

        // list of instance variables

        // stack of custom callbacks provided as parameters to API methods
        this.callbacks = {
            hide: [],
            show: []
        };
        this.checkInterval = null;
        // this will be the user content shown in the tooltip
        this.content;
        // this is the original element which is being applied the tooltipster plugin
        this.$el = $(element);
        // this will be the element which triggers the appearance of the tooltip on hover/click/custom events.
        // it will be the same as this.$el if icons are not used (see in the options), otherwise it will correspond to the created icon
        this.$elProxy;
        this.elProxyPosition;
        this.enabled = true;
        this.options = $.extend({}, defaults, options);
        this.mouseIsOverProxy = false;
        // a unique namespace per instance, for easy selective unbinding
        this.namespace = 'tooltipster-' + Math.round(Math.random() * 100000);
        // status can be either : appearing, shown, disappearing, hidden
        this.status = 'hidden';
        this.timerHide = null;
        this.timerShow = null;
        // this will be the tooltip element (jQuery wrapped HTML element)
        this.$tooltip;

        // for backward compatibility
        this.options.iconTheme = this.options.iconTheme.replace('.', '');
        this.options.theme = this.options.theme.replace('.', '');

        // launch

        this.init();
    }

    Plugin.prototype = {

        init: function () {

            var self = this;

            // disable the plugin on old browsers (including IE7 and lower)
            if (document.querySelector) {

                // note : the content is null (empty) by default and can stay that way if the plugin remains initialized but not fed any content. The tooltip will just not appear.

                // if content is provided in the options, its has precedence over the title attribute. Remark : an empty string is considered content, only 'null' represents the absence of content.
                if (self.options.content !== null) {
                    self.setContent(self.options.content);
                }
                else {
                    // the same remark as above applies : empty strings (like title="") are considered content and will be shown. Do not define any attribute at all if you want to initialize the plugin without content at start.
                    var t = self.$el.attr('title');
                    if (typeof t === 'undefined') t = null;

                    self.setContent(t);
                }

                var c = self.options.functionInit.call(self.$el, self.$el, self.content);
                if (typeof c !== 'undefined') self.setContent(c);

                self.$el
					// strip the title off of the element to prevent the default tooltips from popping up
					.removeAttr('title')
					// to be able to find all instances on the page later (upon window events in particular)
					.addClass('tooltipstered');

                // detect if we're changing the tooltip origin to an icon
                // note about this condition : if the device has touch capability and self.options.iconTouch is false, you'll have no icons event though you may consider your device as a desktop if it also has a mouse. Not sure why someone would have this use case though.
                if ((!deviceHasTouchCapability && self.options.iconDesktop) || (deviceHasTouchCapability && self.options.iconTouch)) {

                    // TODO : the tooltip should be automatically be given an absolute position to be near the origin. Otherwise, when the origin is floating or what, it's going to be nowhere near it and disturb the position flow of the page elements. It will imply that the icon also detects when its origin moves, to follow it : not trivial.
                    // Until it's done, the icon feature does not really make sense since the user still has most of the work to do by himself

                    // if the icon provided is in the form of a string
                    if (typeof self.options.icon === 'string') {
                        // wrap it in a span with the icon class
                        self.$elProxy = $('<span class="' + self.options.iconTheme + '"></span>');
                        self.$elProxy.text(self.options.icon);
                    }
                        // if it is an object (sensible choice)
                    else {
                        // (deep) clone the object if iconCloning == true, to make sure every instance has its own proxy. We use the icon without wrapping, no need to. We do not give it a class either, as the user will undoubtedly style the object on his own and since our css properties may conflict with his own
                        if (self.options.iconCloning) self.$elProxy = self.options.icon.clone(true);
                        else self.$elProxy = self.options.icon;
                    }

                    self.$elProxy.insertAfter(self.$el);
                }
                else {
                    self.$elProxy = self.$el;
                }

                // for 'click' and 'hover' triggers : bind on events to open the tooltip. Closing is now handled in showTooltipNow() because of its bindings.
                // Notes about touch events :
                // - mouseenter, mouseleave and clicks happen even on pure touch devices because they are emulated. deviceIsPureTouch() is a simple attempt to detect them.
                // - on hybrid devices, we do not prevent touch gesture from opening tooltips. It would be too complex to differentiate real mouse events from emulated ones.
                // - we check deviceIsPureTouch() at each event rather than prior to binding because the situation may change during browsing
                if (self.options.trigger == 'hover') {

                    // these binding are for mouse interaction only
                    self.$elProxy
						.on('mouseenter.' + self.namespace, function () {
						    if (!deviceIsPureTouch() || self.options.touchDevices) {
						        self.mouseIsOverProxy = true;
						        self.showTooltip();
						    }
						})
						.on('mouseleave.' + self.namespace, function () {
						    if (!deviceIsPureTouch() || self.options.touchDevices) {
						        self.mouseIsOverProxy = false;
						    }
						});

                    // for touch interaction only
                    if (deviceHasTouchCapability && self.options.touchDevices) {

                        // for touch devices, we immediately display the tooltip because we cannot rely on mouseleave to handle the delay
                        self.$elProxy.on('touchstart.' + self.namespace, function () {
                            self.showTooltipNow();
                        });
                    }
                }
                else if (self.options.trigger == 'click') {

                    // note : for touch devices, we do not bind on touchstart, we only rely on the emulated clicks (triggered by taps)
                    self.$elProxy.on('click.' + self.namespace, function () {
                        if (!deviceIsPureTouch() || self.options.touchDevices) {
                            self.showTooltip();
                        }
                    });
                }
            }
        },

        // this function will schedule the opening of the tooltip after the delay, if there is one
        showTooltip: function () {

            var self = this;

            if (self.status != 'shown' && self.status != 'appearing') {

                if (self.options.delay) {
                    self.timerShow = setTimeout(function () {

                        // for hover trigger, we check if the mouse is still over the proxy, otherwise we do not show anything
                        if (self.options.trigger == 'click' || (self.options.trigger == 'hover' && self.mouseIsOverProxy)) {
                            self.showTooltipNow();
                        }
                    }, self.options.delay);
                }
                else self.showTooltipNow();
            }
        },

        // this function will open the tooltip right away
        showTooltipNow: function (callback) {

            var self = this;

            // call our constructor custom function before continuing
            self.options.functionBefore.call(self.$el, self.$el, function () {

                // continue only if the tooltip is enabled and has any content
                if (self.enabled && self.content !== null) {

                    // save the method callback and cancel hide method callbacks
                    if (callback) self.callbacks.show.push(callback);
                    self.callbacks.hide = [];

                    //get rid of any appearance timer
                    clearTimeout(self.timerShow);
                    self.timerShow = null;
                    clearTimeout(self.timerHide);
                    self.timerHide = null;

                    // if we only want one tooltip open at a time, close all auto-closing tooltips currently open and not already disappearing
                    if (self.options.onlyOne) {
                        $('.tooltipstered').not(self.$el).each(function (i, el) {

                            // we have to use the public methods here
                            var $el = $(el),
								s = $el[pluginName]('status'),
								ac = $el[pluginName]('option', 'autoClose');

                            if (s !== 'hidden' && s !== 'disappearing' && ac) {
                                $el[pluginName]('hide');
                            }
                        });
                    }

                    var finish = function () {
                        self.status = 'shown';

                        // trigger any show method custom callbacks and reset them
                        $.each(self.callbacks.show, function (i, c) { c.call(self.$el); });
                        self.callbacks.show = [];
                    };

                    // if this origin already has its tooltip open
                    if (self.status !== 'hidden') {

                        // the timer (if any) will start (or restart) right now
                        var extraTime = 0;

                        // if it was disappearing, cancel that
                        if (self.status === 'disappearing') {

                            self.status = 'appearing';

                            if (supportsTransitions()) {

                                self.$tooltip
									.clearQueue()
									.removeClass('tooltipster-dying')
									.addClass('tooltipster-' + self.options.animation + '-show');

                                if (self.options.speed > 0) self.$tooltip.delay(self.options.speed);

                                self.$tooltip.queue(finish);
                            }
                            else {
                                // in case the tooltip was currently fading out, bring it back to life
                                self.$tooltip
									.stop()
									.fadeIn(finish);
                            }
                        }
                            // if the tooltip is already open, we still need to trigger the method custom callback
                        else if (self.status === 'shown') {
                            finish();
                        }
                    }
                        // if the tooltip isn't already open, open that sucker up!
                    else {

                        self.status = 'appearing';

                        // the timer (if any) will start when the tooltip has fully appeared after its transition
                        var extraTime = self.options.speed;

                        // get some other settings related to building the tooltip
                        var animation = 'tooltipster-' + self.options.animation,
							animationSpeed = '-webkit-transition-duration: ' + self.options.speed + 'ms; -webkit-animation-duration: ' + self.options.speed + 'ms; -moz-transition-duration: ' + self.options.speed + 'ms; -moz-animation-duration: ' + self.options.speed + 'ms; -o-transition-duration: ' + self.options.speed + 'ms; -o-animation-duration: ' + self.options.speed + 'ms; -ms-transition-duration: ' + self.options.speed + 'ms; -ms-animation-duration: ' + self.options.speed + 'ms; transition-duration: ' + self.options.speed + 'ms; animation-duration: ' + self.options.speed + 'ms;',
							fixedWidth = self.options.fixedWidth > 0 ? 'width:' + Math.round(self.options.fixedWidth) + 'px;' : '',
							maxWidth = self.options.maxWidth > 0 ? 'max-width:' + Math.round(self.options.maxWidth) + 'px;' : '',
							pointerEvents = self.options.interactive ? 'pointer-events: auto;' : '';

                        // build the base of our tooltip
                        self.$tooltip = $('<div class="tooltipster-base ' + self.options.theme + '" style="' + fixedWidth + ' ' + maxWidth + ' ' + pointerEvents + ' ' + animationSpeed + '"><div class="tooltipster-content"></div></div>');

                        // only add the animation class if the user has a browser that supports animations
                        if (supportsTransitions()) self.$tooltip.addClass(animation);

                        // insert the content
                        self.insertContent();
                        if (window.MSApp && window.MSApp.execUnsafeLocalFunction)
                            MSApp.execUnsafeLocalFunction(function () {
                                // attach
                                self.$tooltip.appendTo('body');
                            });
                        else {
                            self.$tooltip.appendTo('body');
                        }


                        // do all the crazy calculations and positioning
                        self.positionTooltip();

                        // call our custom callback since the content of the tooltip is now part of the DOM
                        self.options.functionReady.call(self.$el, self.$el, self.$tooltip);

                        // animate in the tooltip
                        if (supportsTransitions()) {

                            self.$tooltip.addClass(animation + '-show');

                            if (self.options.speed > 0) self.$tooltip.delay(self.options.speed);

                            self.$tooltip.queue(finish);
                        }
                        else {
                            self.$tooltip.css('display', 'none').fadeIn(self.options.speed, finish);
                        }

                        // will check if our tooltip origin is removed while the tooltip is shown
                        self.setCheckInterval();

                        // reposition on scroll (otherwise position:fixed element's tooltips will move away form their origin) and on resize (in case position can/has to be changed)
                        $(window).on('scroll.' + self.namespace + ' resize.' + self.namespace, function () {
                            self.positionTooltip();
                        });

                        // auto-close bindings
                        if (self.options.autoClose) {

                            // in case a listener is already bound for autoclosing (mouse or touch, hover or click), unbind it first
                            $('body').off('.' + self.namespace);

                            // here we'll have to set different sets of bindings for both touch and mouse
                            if (self.options.trigger == 'hover') {

                                // if the user touches the body, hide
                                if (deviceHasTouchCapability) {
                                    // timeout 0 : explanation below in click section
                                    setTimeout(function () {
                                        // we don't want to bind on click here because the initial touchstart event has not yet triggered its click event, which is thus about to happen
                                        $('body').on('touchstart.' + self.namespace, function () {
                                            self.hideTooltip();
                                        });
                                    }, 0);
                                }

                                // if we have to allow interaction
                                if (self.options.interactive) {

                                    // touch events inside the tooltip must not close it
                                    if (deviceHasTouchCapability) {
                                        self.$tooltip.on('touchstart.' + self.namespace, function (event) {
                                            event.stopPropagation();
                                        });
                                    }

                                    // as for mouse interaction, we get rid of the tooltip only after the mouse has spent some time out of it
                                    var tolerance = null;

                                    self.$elProxy.add(self.$tooltip)
										// hide after some time out of the proxy and the tooltip
										.on('mouseleave.' + self.namespace + '-autoClose', function () {
										    clearTimeout(tolerance);
										    tolerance = setTimeout(function () {
										        self.hideTooltip();
										    }, self.options.interactiveTolerance);
										})
										// suspend timeout when the mouse is over the proxy or the tooltip
										.on('mouseenter.' + self.namespace + '-autoClose', function () {
										    clearTimeout(tolerance);
										});
                                }
                                    // if this is a non-interactive tooltip, get rid of it if the mouse leaves
                                else {
                                    self.$elProxy.on('mouseleave.' + self.namespace + '-autoClose', function () {
                                        self.hideTooltip();
                                    });
                                }
                            }
                                // here we'll set the same bindings for both clicks and touch on the body to hide the tooltip
                            else if (self.options.trigger == 'click') {

                                // use a timeout to prevent immediate closing if the method was called on a click event and if options.delay == 0 (because of bubbling)
                                setTimeout(function () {
                                    $('body').on('click.' + self.namespace + ' touchstart.' + self.namespace, function () {
                                        self.hideTooltip();
                                    });
                                }, 0);

                                // if interactive, we'll stop the events that were emitted from inside the tooltip to stop autoClosing
                                if (self.options.interactive) {

                                    // note : the touch events will just not be used if the plugin is not enabled on touch devices
                                    self.$tooltip.on('click.' + self.namespace + ' touchstart.' + self.namespace, function (event) {
                                        event.stopPropagation();
                                    });
                                }
                            }
                        }
                    }

                    // if we have a timer set, let the countdown begin
                    if (self.options.timer > 0) {

                        self.timerHide = setTimeout(function () {
                            self.timerHide = null;
                            self.hideTooltip();
                        }, self.options.timer + extraTime);
                    }
                }
            });
        },

        setCheckInterval: function () {

            var self = this;

            self.checkInterval = setInterval(function () {

                // if the tooltip and/or its interval should be stopped
                if (
                    // if the origin has been removed
						$('body').find(self.$el).length === 0
                    // if the elProxy has been removed
					|| $('body').find(self.$elProxy).length === 0
                    // if the tooltip has been closed
					|| self.status == 'hidden'
                    // if the tooltip has somehow been removed
					|| $('body').find(self.$tooltip).length === 0
				) {
                    // remove the tooltip if it's still here
                    if (self.status == 'shown' || self.status == 'appearing') self.hideTooltip();

                    // clear this interval as it is no longer necessary
                    self.cancelCheckInterval();
                }
                    // if everything is alright
                else {
                    // compare the former and current positions of the elProxy to reposition the tooltip if need be
                    if (self.options.positionTracker) {

                        var p = self.positionInfo(self.$elProxy),
							identical = false;

                        // compare size first (a change requires repositioning too)
                        if (areEqual(p.dimension, self.elProxyPosition.dimension)) {

                            // for elements with a fixed position, we track the top and left properties (relative to window)
                            if (self.$elProxy.css('position') === 'fixed') {
                                if (areEqual(p.position, self.elProxyPosition.position)) identical = true;
                            }
                                // otherwise, track total offset (relative to document)
                            else {
                                if (areEqual(p.offset, self.elProxyPosition.offset)) identical = true;
                            }
                        }

                        if (!identical) {
                            self.positionTooltip();
                        }
                    }
                }
            }, 200);
        },

        cancelCheckInterval: function () {
            clearInterval(this.checkInterval);
            // clean delete
            this.checkInterval = null;
        },

        hideTooltip: function (callback) {

            var self = this;

            // save the method custom callback and cancel any show method custom callbacks
            if (callback) self.callbacks.hide.push(callback);
            self.callbacks.show = [];

            // get rid of any appearance timeout
            clearTimeout(self.timerShow);
            self.timerShow = null;
            clearTimeout(self.timerHide);
            self.timerHide = null;

            var finishCallbacks = function () {
                // trigger any hide method custom callbacks and reset them
                $.each(self.callbacks.hide, function (i, c) { c.call(self.$el); });
                self.callbacks.hide = [];
            };

            // hide
            if (self.status == 'shown' || self.status == 'appearing') {

                self.status = 'disappearing';

                var finish = function () {

                    self.status = 'hidden';

                    // detach our content object first, so the next jQuery's remove() call does not unbind its event handlers
                    if (typeof self.content == 'object' && self.content !== null) {
                        self.content.detach();
                    }

                    self.$tooltip.remove();
                    self.$tooltip = null;

                    // unbind orientationchange, scroll and resize listeners
                    $(window).off('.' + self.namespace);

                    // unbind any auto-closing click/touch listeners
                    $('body').off('.' + self.namespace);

                    // unbind any auto-closing hover listeners
                    self.$elProxy.off('.' + self.namespace + '-autoClose');

                    // call our constructor custom callback function
                    self.options.functionAfter.call(self.$el, self.$el);

                    // call our method custom callbacks functions
                    finishCallbacks();
                };

                if (supportsTransitions()) {

                    self.$tooltip
						.clearQueue()
						.removeClass('tooltipster-' + self.options.animation + '-show')
						// for transitions only
						.addClass('tooltipster-dying');

                    if (self.options.speed > 0) self.$tooltip.delay(self.options.speed);

                    self.$tooltip.queue(finish);
                }
                else {
                    self.$tooltip
						.stop()
						.fadeOut(self.options.speed, finish);
                }
            }
                // if the tooltip is already hidden, we still need to trigger the method custom callback
            else if (self.status == 'hidden') {
                finishCallbacks();
            }
        },

        setContent: function (content) {
            // clone if asked. Cloning the object makes sure that each instance has its own version of the content (in case a same object were provided for several instances)
            // reminder : typeof null === object
            if (typeof content === 'object' && content !== null && this.options.contentCloning) {
                content = content.clone(true);
            }
            this.content = content;
        },

        insertContent: function () {

            var self = this,
				$d = this.$tooltip.find('.tooltipster-content');

            if (typeof self.content === 'string' && !self.options.contentAsHTML) {
                $d.text(self.content);
            }
            else {
                $d
					.empty()
					.append(self.content);
            }
        },

        updateTooltip: function (content) {

            var self = this;

            // change the content
            self.setContent(content);

            if (self.content !== null) {

                // update the tooltip if it is open
                if (self.status !== 'hidden') {

                    // reset the content in the tooltip
                    self.insertContent();

                    // reposition and resize the tooltip
                    self.positionTooltip();

                    // if we want to play a little animation showing the content changed
                    if (self.options.updateAnimation) {

                        if (supportsTransitions()) {

                            self.$tooltip.css({
                                'width': '',
                                '-webkit-transition': 'all ' + self.options.speed + 'ms, width 0ms, height 0ms, left 0ms, top 0ms',
                                '-moz-transition': 'all ' + self.options.speed + 'ms, width 0ms, height 0ms, left 0ms, top 0ms',
                                '-o-transition': 'all ' + self.options.speed + 'ms, width 0ms, height 0ms, left 0ms, top 0ms',
                                '-ms-transition': 'all ' + self.options.speed + 'ms, width 0ms, height 0ms, left 0ms, top 0ms',
                                'transition': 'all ' + self.options.speed + 'ms, width 0ms, height 0ms, left 0ms, top 0ms'
                            }).addClass('tooltipster-content-changing');

                            // reset the CSS transitions and finish the change animation
                            setTimeout(function () {

                                if (self.status != 'hidden') {

                                    self.$tooltip.removeClass('tooltipster-content-changing');

                                    // after the changing animation has completed, reset the CSS transitions
                                    setTimeout(function () {

                                        if (self.status !== 'hidden') {
                                            self.$tooltip.css({
                                                '-webkit-transition': self.options.speed + 'ms',
                                                '-moz-transition': self.options.speed + 'ms',
                                                '-o-transition': self.options.speed + 'ms',
                                                '-ms-transition': self.options.speed + 'ms',
                                                'transition': self.options.speed + 'ms'
                                            });
                                        }
                                    }, self.options.speed);
                                }
                            }, self.options.speed);
                        }
                        else {
                            self.$tooltip.fadeTo(self.options.speed, 0.5, function () {
                                if (self.status != 'hidden') {
                                    self.$tooltip.fadeTo(self.options.speed, 1);
                                }
                            });
                        }
                    }
                }
            }
            else {
                self.hideTooltip();
            }
        },

        positionInfo: function ($el) {
            return {
                dimension: {
                    height: $el.outerHeight(false),
                    width: $el.outerWidth(false)
                },
                offset: $el.offset(),
                position: {
                    left: parseInt($el.css('left')),
                    top: parseInt($el.css('top'))
                }
            };
        },

        positionTooltip: function () {

            var self = this;

            // in case the tooltip has been removed from DOM manually
            if ($('body').find(self.$tooltip).length !== 0) {

                // reset width
                self.$tooltip.css('width', '');

                // find variables to determine placement
                self.elProxyPosition = self.positionInfo(self.$elProxy);
                var arrowReposition = null,
					windowWidth = $(window).width(),
					// shorthand
					proxy = self.elProxyPosition,
					tooltipWidth = self.$tooltip.outerWidth(false),
					tooltipInnerWidth = self.$tooltip.innerWidth() + 1, // this +1 stops FireFox from sometimes forcing an additional text line
					tooltipHeight = self.$tooltip.outerHeight(false);

                // if this is an <area> tag inside a <map>, all hell breaks loose. Recaclulate all the measurements based on coordinates
                if (self.$elProxy.is('area')) {
                    var areaShape = self.$elProxy.attr('shape'),
						mapName = self.$elProxy.parent().attr('name'),
						map = $('img[usemap="#' + mapName + '"]'),
						mapOffsetLeft = map.offset().left,
						mapOffsetTop = map.offset().top,
						areaMeasurements = self.$elProxy.attr('coords') !== undefined ? self.$elProxy.attr('coords').split(',') : undefined;

                    if (areaShape == 'circle') {
                        var areaLeft = parseInt(areaMeasurements[0]),
							areaTop = parseInt(areaMeasurements[1]),
							areaWidth = parseInt(areaMeasurements[2]);
                        proxy.dimension.height = areaWidth * 2;
                        proxy.dimension.width = areaWidth * 2;
                        proxy.offset.top = mapOffsetTop + areaTop - areaWidth;
                        proxy.offset.left = mapOffsetLeft + areaLeft - areaWidth;
                    }
                    else if (areaShape == 'rect') {
                        var areaLeft = parseInt(areaMeasurements[0]),
							areaTop = parseInt(areaMeasurements[1]),
							areaRight = parseInt(areaMeasurements[2]),
							areaBottom = parseInt(areaMeasurements[3]);
                        proxy.dimension.height = areaBottom - areaTop;
                        proxy.dimension.width = areaRight - areaLeft;
                        proxy.offset.top = mapOffsetTop + areaTop;
                        proxy.offset.left = mapOffsetLeft + areaLeft;
                    }
                    else if (areaShape == 'poly') {
                        var areaXs = [],
							areaYs = [],
							areaSmallestX = 0,
							areaSmallestY = 0,
							areaGreatestX = 0,
							areaGreatestY = 0,
							arrayAlternate = 'even';

                        for (i = 0; i < areaMeasurements.length; i++) {
                            var areaNumber = parseInt(areaMeasurements[i]);

                            if (arrayAlternate == 'even') {
                                if (areaNumber > areaGreatestX) {
                                    areaGreatestX = areaNumber;
                                    if (i === 0) {
                                        areaSmallestX = areaGreatestX;
                                    }
                                }

                                if (areaNumber < areaSmallestX) {
                                    areaSmallestX = areaNumber;
                                }

                                arrayAlternate = 'odd';
                            }
                            else {
                                if (areaNumber > areaGreatestY) {
                                    areaGreatestY = areaNumber;
                                    if (i == 1) {
                                        areaSmallestY = areaGreatestY;
                                    }
                                }

                                if (areaNumber < areaSmallestY) {
                                    areaSmallestY = areaNumber;
                                }

                                arrayAlternate = 'even';
                            }
                        }

                        proxy.dimension.height = areaGreatestY - areaSmallestY;
                        proxy.dimension.width = areaGreatestX - areaSmallestX;
                        proxy.offset.top = mapOffsetTop + areaSmallestY;
                        proxy.offset.left = mapOffsetLeft + areaSmallestX;
                    }
                    else {
                        proxy.dimension.height = map.outerHeight(false);
                        proxy.dimension.width = map.outerWidth(false);
                        proxy.offset.top = mapOffsetTop;
                        proxy.offset.left = mapOffsetLeft;
                    }
                }

                // hardcoding the width and removing the padding fixed an issue with the tooltip width collapsing when the window size is small
                if (self.options.fixedWidth === 0) {
                    self.$tooltip.css({
                        'width': Math.round(tooltipInnerWidth) + 'px',
                        'padding-left': '0px',
                        'padding-right': '0px'
                    });
                }

                // our function and global vars for positioning our tooltip
                var myLeft = 0,
					myLeftMirror = 0,
					myTop = 0,
					offsetY = parseInt(self.options.offsetY),
					offsetX = parseInt(self.options.offsetX),
					// this is the arrow position that will eventually be used. It may differ from the position option if the tooltip cannot be displayed in this position
					practicalPosition = self.options.position;

                // a function to detect if the tooltip is going off the screen horizontally. If so, reposition the crap out of it!
                function dontGoOffScreenX() {

                    var windowLeft = $(window).scrollLeft();

                    // if the tooltip goes off the left side of the screen, line it up with the left side of the window
                    if ((myLeft - windowLeft) < 0) {
                        arrowReposition = myLeft - windowLeft;
                        myLeft = windowLeft;
                    }

                    // if the tooltip goes off the right of the screen, line it up with the right side of the window
                    if (((myLeft + tooltipWidth) - windowLeft) > windowWidth) {
                        arrowReposition = myLeft - ((windowWidth + windowLeft) - tooltipWidth);
                        myLeft = (windowWidth + windowLeft) - tooltipWidth;
                    }
                }

                // a function to detect if the tooltip is going off the screen vertically. If so, switch to the opposite!
                function dontGoOffScreenY(switchTo, switchFrom) {
                    // if it goes off the top off the page
                    if (((proxy.offset.top - $(window).scrollTop() - tooltipHeight - offsetY - 12) < 0) && (switchFrom.indexOf('top') > -1)) {
                        practicalPosition = switchTo;
                    }

                    // if it goes off the bottom of the page
                    if (((proxy.offset.top + proxy.dimension.height + tooltipHeight + 12 + offsetY) > ($(window).scrollTop() + $(window).height())) && (switchFrom.indexOf('bottom') > -1)) {
                        practicalPosition = switchTo;
                        myTop = (proxy.offset.top - tooltipHeight) - offsetY - 12;
                    }
                }

                if (practicalPosition == 'top') {
                    var leftDifference = (proxy.offset.left + tooltipWidth) - (proxy.offset.left + proxy.dimension.width);
                    myLeft = (proxy.offset.left + offsetX) - (leftDifference / 2);
                    myTop = (proxy.offset.top - tooltipHeight) - offsetY - 12;
                    dontGoOffScreenX();
                    dontGoOffScreenY('bottom', 'top');
                }

                if (practicalPosition == 'top-left') {
                    myLeft = proxy.offset.left + offsetX;
                    myTop = (proxy.offset.top - tooltipHeight) - offsetY - 12;
                    dontGoOffScreenX();
                    dontGoOffScreenY('bottom-left', 'top-left');
                }

                if (practicalPosition == 'top-right') {
                    myLeft = (proxy.offset.left + proxy.dimension.width + offsetX) - tooltipWidth;
                    myTop = (proxy.offset.top - tooltipHeight) - offsetY - 12;
                    dontGoOffScreenX();
                    dontGoOffScreenY('bottom-right', 'top-right');
                }

                if (practicalPosition == 'bottom') {
                    var leftDifference = (proxy.offset.left + tooltipWidth) - (proxy.offset.left + proxy.dimension.width);
                    myLeft = proxy.offset.left - (leftDifference / 2) + offsetX;
                    myTop = (proxy.offset.top + proxy.dimension.height) + offsetY + 12;
                    dontGoOffScreenX();
                    dontGoOffScreenY('top', 'bottom');
                }

                if (practicalPosition == 'bottom-left') {
                    myLeft = proxy.offset.left + offsetX;
                    myTop = (proxy.offset.top + proxy.dimension.height) + offsetY + 12;
                    dontGoOffScreenX();
                    dontGoOffScreenY('top-left', 'bottom-left');
                }

                if (practicalPosition == 'bottom-right') {
                    myLeft = (proxy.offset.left + proxy.dimension.width + offsetX) - tooltipWidth;
                    myTop = (proxy.offset.top + proxy.dimension.height) + offsetY + 12;
                    dontGoOffScreenX();
                    dontGoOffScreenY('top-right', 'bottom-right');
                }

                if (practicalPosition == 'left') {
                    myLeft = proxy.offset.left - offsetX - tooltipWidth - 12;
                    myLeftMirror = proxy.offset.left + offsetX + proxy.dimension.width + 12;
                    var topDifference = (proxy.offset.top + tooltipHeight) - (proxy.offset.top + self.$elProxy.outerHeight(false));
                    myTop = proxy.offset.top - (topDifference / 2) - offsetY;

                    // if the tooltip goes off boths sides of the page
                    if ((myLeft < 0) && ((myLeftMirror + tooltipWidth) > windowWidth)) {
                        var borderWidth = parseFloat(self.$tooltip.css('border-width')) * 2,
							newWidth = (tooltipWidth + myLeft) - borderWidth;
                        self.$tooltip.css('width', newWidth + 'px');

                        tooltipHeight = self.$tooltip.outerHeight(false);
                        myLeft = proxy.offset.left - offsetX - newWidth - 12 - borderWidth;
                        topDifference = (proxy.offset.top + tooltipHeight) - (proxy.offset.top + self.$elProxy.outerHeight(false));
                        myTop = proxy.offset.top - (topDifference / 2) - offsetY;
                    }

                        // if it only goes off one side, flip it to the other side
                    else if (myLeft < 0) {
                        myLeft = proxy.offset.left + offsetX + proxy.dimension.width + 12;
                        arrowReposition = 'left';
                    }
                }

                if (practicalPosition == 'right') {
                    myLeft = proxy.offset.left + offsetX + proxy.dimension.width + 12;
                    myLeftMirror = proxy.offset.left - offsetX - tooltipWidth - 12;
                    var topDifference = (proxy.offset.top + tooltipHeight) - (proxy.offset.top + self.$elProxy.outerHeight(false));
                    myTop = proxy.offset.top - (topDifference / 2) - offsetY;

                    // if the tooltip goes off boths sides of the page
                    if (((myLeft + tooltipWidth) > windowWidth) && (myLeftMirror < 0)) {
                        var borderWidth = parseFloat(self.$tooltip.css('border-width')) * 2,
							newWidth = (windowWidth - myLeft) - borderWidth;
                        self.$tooltip.css('width', newWidth + 'px');

                        tooltipHeight = self.$tooltip.outerHeight(false);
                        topDifference = (proxy.offset.top + tooltipHeight) - (proxy.offset.top + self.$elProxy.outerHeight(false));
                        myTop = proxy.offset.top - (topDifference / 2) - offsetY;
                    }

                        // if it only goes off one side, flip it to the other side
                    else if ((myLeft + tooltipWidth) > windowWidth) {
                        myLeft = proxy.offset.left - offsetX - tooltipWidth - 12;
                        arrowReposition = 'right';
                    }
                }

                // if arrow is set true, style it and append it
                if (self.options.arrow) {

                    var arrowClass = 'tooltipster-arrow-' + practicalPosition;

                    // set color of the arrow
                    if (self.options.arrowColor.length < 1) {
                        var arrowColor = self.$tooltip.css('background-color');
                    }
                    else {
                        var arrowColor = self.options.arrowColor;
                    }

                    // if the tooltip was going off the page and had to re-adjust, we need to update the arrow's position
                    if (!arrowReposition) {
                        arrowReposition = '';
                    }
                    else if (arrowReposition == 'left') {
                        arrowClass = 'tooltipster-arrow-right';
                        arrowReposition = '';
                    }
                    else if (arrowReposition == 'right') {
                        arrowClass = 'tooltipster-arrow-left';
                        arrowReposition = '';
                    }
                    else {
                        arrowReposition = 'left:' + Math.round(arrowReposition) + 'px;';
                    }

                    // building the logic to create the border around the arrow of the tooltip
                    if ((practicalPosition == 'top') || (practicalPosition == 'top-left') || (practicalPosition == 'top-right')) {
                        var tooltipBorderWidth = parseFloat(self.$tooltip.css('border-bottom-width')),
							tooltipBorderColor = self.$tooltip.css('border-bottom-color');
                    }
                    else if ((practicalPosition == 'bottom') || (practicalPosition == 'bottom-left') || (practicalPosition == 'bottom-right')) {
                        var tooltipBorderWidth = parseFloat(self.$tooltip.css('border-top-width')),
							tooltipBorderColor = self.$tooltip.css('border-top-color');
                    }
                    else if (practicalPosition == 'left') {
                        var tooltipBorderWidth = parseFloat(self.$tooltip.css('border-right-width')),
							tooltipBorderColor = self.$tooltip.css('border-right-color');
                    }
                    else if (practicalPosition == 'right') {
                        var tooltipBorderWidth = parseFloat(self.$tooltip.css('border-left-width')),
							tooltipBorderColor = self.$tooltip.css('border-left-color');
                    }
                    else {
                        var tooltipBorderWidth = parseFloat(self.$tooltip.css('border-bottom-width')),
							tooltipBorderColor = self.$tooltip.css('border-bottom-color');
                    }

                    if (tooltipBorderWidth > 1) {
                        tooltipBorderWidth++;
                    }

                    var arrowBorder = '';
                    if (tooltipBorderWidth !== 0) {
                        var arrowBorderSize = '',
							arrowBorderColor = 'border-color: ' + tooltipBorderColor + ';';
                        if (arrowClass.indexOf('bottom') !== -1) {
                            arrowBorderSize = 'margin-top: -' + Math.round(tooltipBorderWidth) + 'px;';
                        }
                        else if (arrowClass.indexOf('top') !== -1) {
                            arrowBorderSize = 'margin-bottom: -' + Math.round(tooltipBorderWidth) + 'px;';
                        }
                        else if (arrowClass.indexOf('left') !== -1) {
                            arrowBorderSize = 'margin-right: -' + Math.round(tooltipBorderWidth) + 'px;';
                        }
                        else if (arrowClass.indexOf('right') !== -1) {
                            arrowBorderSize = 'margin-left: -' + Math.round(tooltipBorderWidth) + 'px;';
                        }
                        arrowBorder = '<span class="tooltipster-arrow-border" style="' + arrowBorderSize + ' ' + arrowBorderColor + ';"></span>';
                    }

                    // if the arrow already exists, remove and replace it
                    self.$tooltip.find('.tooltipster-arrow').remove();

                    // build out the arrow and append it		
                    var arrowConstruct = '<div class="' + arrowClass + ' tooltipster-arrow" style="' + arrowReposition + '">' + arrowBorder + '<span style="border-color:' + arrowColor + ';"></span></div>';
                    self.$tooltip.append(arrowConstruct);
                }

                // position the tooltip
                self.$tooltip.css({ 'top': Math.round(myTop) + 'px', 'left': Math.round(myLeft) + 'px' });
            }
        }
    };

    $.fn[pluginName] = function () {

        // for using in closures
        var args = arguments;

        // if we are not in the context of jQuery wrapped HTML element(s) :
        // this happens when calling static methods in the form $.fn.tooltipster('methodName'), or when calling $(sel).tooltipster('methodName or options') where $(sel) does not match anything
        if (this.length === 0) {

            // if the first argument is a method name
            if (typeof args[0] === 'string') {

                var methodIsStatic = true;

                // list static methods here (usable by calling $.fn.tooltipster('methodName');)
                switch (args[0]) {

                    case 'setDefaults':
                        // change default options for all future instances
                        $.extend(defaults, args[1]);
                        break;

                    default:
                        methodIsStatic = false;
                        break;
                }

                // $.fn.tooltipster('methodName') calls will return true
                if (methodIsStatic) return true;
                    // $(sel).tooltipster('methodName') calls will return the list of objects event though it's empty because chaining should work on empty lists
                else return this;
            }
                // the first argument is undefined or an object of options : we are initalizing but there is no element matched by selector
            else {
                // still chainable : same as above
                return this;
            }
        }
            // this happens when calling $(sel).tooltipster('methodName or options') where $(sel) matches one or more elements
        else {

            // method calls
            if (typeof args[0] === 'string') {

                var v = '#*$~&';

                this.each(function () {

                    // self represent the instance of the tooltipster plugin associated to the current HTML object of the loop
                    var self = $(this).data('tooltipster');

                    // if the current element is a tooltipster instance
                    if (self) {
                        switch (args[0]) {

                            case 'content':
                                // 'update' is deprecated but kept for retrocompatibility
                            case 'update':
                                // getter method
                                if (typeof args[1] === 'undefined') {
                                    v = self.content;
                                    // return false to stop .each iteration on the first element matched by the selector
                                    return false;
                                }
                                    // setter method
                                else {
                                    self.updateTooltip(args[1]);
                                    break;
                                }

                            case 'destroy':
                                self.hideTooltip();

                                if (self.$el[0] !== self.$elProxy[0]) self.$elProxy.remove();

                                // old school technique when outerHTML is not supported
                                var stringifiedContent = (typeof self.content === 'string') ? self.content : $('<div></div>').append(self.content).html();

                                self.$el
									.removeClass('tooltipstered')
									.attr('title', stringifiedContent)
									.removeData('tooltipster')
									.off('.' + self.namespace);
                                break;

                            case 'disable':
                                // hide first, in case the tooltip would not disappear on its own (autoClose false)
                                self.hideTooltip();
                                self.enabled = false;
                                break;

                            case 'elementIcon':
                                v = (self.$el[0] !== self.$elProxy[0]) ? self.$elProxy[0] : undefined;
                                // return false : same as above
                                return false;

                            case 'elementTooltip':
                                v = self.$tooltip ? self.$tooltip[0] : undefined;
                                // return false : same as above
                                return false;

                            case 'enable':
                                self.enabled = true;
                                break;

                            case 'hide':
                                self.hideTooltip(args[1]);
                                break;

                                // for internal use only
                            case 'option':
                                v = self.options[args[1]];
                                return false;

                            case 'reposition':
                                self.positionTooltip();
                                break;

                            case 'show':
                                self.showTooltipNow(args[1]);
                                break;

                                // for internal use use only, not part of the public API
                            case 'status':
                                v = self.status;
                                return false;

                            default:
                                throw new Error('Unknown method .tooltipster("' + args[0] + '")');
                                break;
                        }
                    }
                    else {
                        throw new Error('You called Tooltipster\'s "' + args[0] + '" method on an uninitialized element');
                    }
                });

                return (v !== '#*$~&') ? v : this;
            }
                // first argument is undefined or an object : the tooltip is initializing
            else {
                // initialize a tooltipster instance for each element if it doesn't already have one, and attach the object to it
                return this.each(function () {

                    if (!$(this).data('tooltipster')) {
                        $(this).data('tooltipster', new Plugin(this, args[0]));
                    }
                });
            }
        }
    };

    // quick & dirty compare function (not bijective nor multidimensional)
    function areEqual(a, b) {
        var same = true;
        $.each(a, function (i, el) {
            if (typeof b[i] === 'undefined' || a[i] !== b[i]) {
                same = false;
                return false;
            }
        });
        return same;
    }

    // detect if this device can trigger touch events
    var deviceHasTouchCapability = !!('ontouchstart' in window);

    // we'll assume the device has no mouse until we detect any mouse movement
    var deviceHasMouse = false;
    $('body').one('mousemove', function () {
        deviceHasMouse = true;
    });

    function deviceIsPureTouch() {
        return (!deviceHasMouse && deviceHasTouchCapability);
    }

    // detecting support for CSS transitions
    function supportsTransitions() {
        var b = document.body || document.documentElement,
			s = b.style,
			p = 'transition';

        if (typeof s[p] == 'string') { return true; }

        v = ['Moz', 'Webkit', 'Khtml', 'O', 'ms'],
		p = p.charAt(0).toUpperCase() + p.substr(1);
        for (var i = 0; i < v.length; i++) {
            if (typeof s[v[i] + p] == 'string') { return true; }
        }
        return false;
    }
})(jQuery, window, document);
